Aminet 1/Aminet - June 1993 [Walnut Creek].iso/usenet/sources/volume91/utilitys/memometr/part02

Internet Message Format | 1991-06-18 | 69.0 KB

Path: news.larc.nasa.gov!amiga-request
From: [e-mail] (Amiga Sources/Binaries Moderator)
Subject: v91i121: MemMometer 2.20 - memory gauge, Part02/02
Reply-To: [e-mail] (Howard Hull)
Newsgroups: comp.sources.amiga
Message-ID: <[e-mail]>
References: <[e-mail]>
Date: 14 Jun 91 22:30:41 GMT
Approved: [e-mail] (Tad Guy)
X-Mail-Submissions-To: [e-mail]
X-Post-Discussions-To: comp.sys.amiga.misc

Submitted-by: [e-mail] (Howard Hull)
Posting-number: Volume 91, Issue 121
Archive-name: utilities/memometer-2.20/part02

#!/bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 2 (of 2)."
# Contents:  mm.c mminit.c
# Wrapped by tadguy@ab20 on Fri Jun 14 18:30:39 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'mm.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'mm.c'\"
else
echo shar: Extracting \"'mm.c'\" \(38693 characters\)
sed "s/^X//" >'mm.c' <<'END_OF_FILE'
X/* : ai=0 bk=0 ts=8 */
X#include "mm.h"
X
X#define FREEPEN -1L           /* workbench screen default colors */
X#define REQ_WINDOW_WIDTH 319L /* width of warning requester window */
X#define REQ_WINDOW_HEIGHT 79L /* height of warning requester window */
X
X#define SOK        0x001f     /* memory allocation control masks */
X#define S1         0x0001
X#define S2         0x0002
X#define S4         0x0004
X#define S8         0x0008
X#define SA         0x0010
X#define C1         0xfffe
X#define C2         0xfffd
X#define C4         0xfffb
X#define C8         0xfff7
X#define CA         0xffef
X#define AARRRGH    20L         /* hang 20, cats, we're startin ta curl! */
X
X#define EXTENSION  16L         /* allocation request increment */
X
X#define FRAGS FALSE                          /* frags mode control boolian */
X#define WARPS TRUE                           /* warps mode control boolian */
X#define EVENMASK 0x7ffffffe           /* used to prevent odd address traps */
X#define CLIHEIGHT 200L                             /* window scaling stuff */
X#define SIZEGAD 9L
X#define DRAGBAR 10L
X#define BORDER 2L
X#define WINW 16L                                   /* initial window width */
X#define WINH (long)(CLIHEIGHT - SIZEGAD - DRAGBAR)   /* initial win height */
X#define MINH 81L                              /* shortest allowable window */
X#define MAXH 576L                              /* longest allowable window */
X#define BART 1L                               /* title bar F text location */
X#define BARH (long)(WINH - SIZEGAD - DRAGBAR)                /* bar height */
X#define BARS (long)(BARH + 1)        /* number of memory items to allocate */
X#define BARB (long)(BARH + DRAGBAR - 1)        /* bottom of mercury column */
X#define BARE (long)(BARB + BORDER)              /* bar end E text position */
X#define BARW (long)(((WINW - (2 * BORDER)) / 3) - 1)  /* 3 memfragmometers */
X#define LEFT BORDER                   /* SLOW : since we're syncopated, we */
X#define MIDDLE (LEFT + BARW + 1)      /* SLOW-FAST : do it going from bar  */
X#define RIGHT (MIDDLE + BARW + 1)     /* FAST :to bar at an irregular pace */
X#define RTEXT - 4L        /* offset for three char E/F text from left edge */
X#define STARTVAL 64L    /* start by getting enough storage for a few frags */
X#define TMARK 100000L                     /* timer granule in microseconds */
X#define TICKIES (long)(1000000/TMARK)       /* number of TMARKS per second */
X
X/* typedef short BOOL */        /* this is in include/exec/types.h */
X
Xstruct IntuitionBase *IntuitionBase=NULL ;
Xstruct Window *window ;
Xstruct IntuiMessage *message;
X/* struct IntuiMessage *GetMsg(); */        /* in functions.h */
X
Xstruct GfxBase *GfxBase=NULL ;
X
Xstruct IOStdReq *timermsg=NULL;
Xstruct MsgPort *timerport=NULL;
XULONG  timerbit=NULL;
X
X
Xextern void InitProjItems();        /* this stuff is in the mminit section */
Xextern void InitSetupItems();
Xextern void InitPrioItems();
Xextern void InitChipItems();
Xextern void InitChipAItems();
Xextern void InitSFItems();
Xextern void InitSFAItems();
Xextern void InitFastItems();
Xextern void InitFastAItems();
Xextern void InitMenu();
Xextern void StartMenus();
X
XBOOL p_mode = FRAGS;          /* preset frags mode = 0, warps mode = 1 */
X                              /* note: mode preset used as request for */
X                              /*       change to warps mode after the  */
X                              /*       first pass with frags mode set! */
Xlong p_rate = 2;              /* preset sample interval, secs see menu */
Xlong p_priority = 0;          /* preset priority, range -128 to +127   */
X                              /* note: pri greater than zero is risky! */
X                              /* keep in mind AmigaDOS priorities:     */
X                              /* input.device 20, FileSystem 10, and   */
X                              /* trackdisk.device, CON: 5 also if MM   */
X                              /* is started from a CLI without the Run */
X                              /* then that CLI inherits MM's priority! */
Xlong p_chip = 512;            /* preset chip mem size, kbytes see menu */
Xlong p_chipa = 0;             /* preset chip mem address, kb  see menu */
Xlong p_sf = 0;                /* preset slowfast mem size, kb see menu */
Xlong p_sfa = 2048;            /* preset slowfast mem addr, kb see menu */
Xlong p_fast = 0;              /* preset fast mem size, mbytes see menu */
Xlong p_fasta = -1;            /* preset fast mem addr, mbytes see menu */
X                              /* zero or neg fasta is offset below the */
X                              /* A3000 fast ram ceiling, aka 0x7000000 */
X
Xstatic BOOL mode;                    /* uninitialized for mode control */
Xstatic BOOL mmode;                   /* uninitialized for mode  menu */
Xstatic long delayval;                /* uninitialized for delay menu */
Xstatic long priority;                /* uninitialized for priority menu */
Xstatic long lastpri;                 /* uninitialized for priority incr */
Xstatic long cmemsize;                /* uninitialized for chip  menu */
Xstatic long cmembase;                /* uninitialized for chipa menu */
Xstatic long sfmemsize;               /* uninitialized for sf    menu */
Xstatic long sfmembase;               /* uninitialized for sfa   menu */
Xstatic long fmemsize;                /* uninitialized for fast  menu */
Xstatic long fmembase;                /* uninitialized for fasta menu */
X
Xstatic USHORT log ;                  /* memory allocation success flags */
Xstatic BOOL things_are_cool = TRUE ; /* tells when to close the window  */
Xstatic BOOL intsig = FALSE ;         /* intuition message detector */
Xstatic USHORT chgflag = TRUE ;       /* menu request to adjust columns */
Xstatic long chip[3], fast[3] ;       /* place to keep mem header pointers */
Xstatic ULONG  *chunkv ;              /* demand allocated for frag chunks */
Xstatic ULONG  *sizev ;               /* demand allocated for frag sizes */
Xstatic ULONG  *csum ;                /* a col's height worth of checksums */
Xstatic ULONG  *oldcsum ;             /* same height worth of old checksums */
Xstatic USHORT *cell;                 /* 1 cell per pixel height of mercury */
Xstatic long xl, xr ;                 /* used to Draw() memmometer segments */
Xstatic long frags = STARTVAL ;       /* # of demand allocated frag items */
Xstatic long warps = BARS ;           /* # of demand allocated column items */
Xstatic long barh = BARH ;            /* EVEN #'d height of mercury column */
Xstatic long barb = BARB ;            /* bottom position of mercury column */
Xstatic short ticker = TICKIES ;      /* initialized delay tick variable */
X
X/* struct RastPort *rp ; */          /* wonder why we don't need this... ? */
X
X
Xstatic struct TextAttr myfont = {
X   (STRPTR) "topaz.font",
X   TOPAZ_EIGHTY,
X   0,
X   0
X};
X/* E newsize gadget refresh text */
Xstatic char ebuf[4] = " E " ;
Xstatic struct IntuiText e_text = {
X   BLUP, WHTP,
X   JAM2,
X   0, BARE,
X   &myfont,
X   (UBYTE *)ebuf,
X   NULL
X};
X/* F title refresh text */
Xstatic char fbuf[4] = " F " ;
Xstatic struct IntuiText f_text = {
X   BLUP, WHTP,
X   JAM2,
X   0, BART,
X   &myfont,
X   (UBYTE *)fbuf,
X   &e_text
X};
Xstatic struct NewWindow newwindow = {
X   0,                                        /* left edge */
X   10,                                       /* top edge */
X   WINW,                                     /* width */
X   WINH,                                     /* height */
X   0,                                        /* detail pen */
X   1,                                        /* block pen */
X   MENUPICK | NEWSIZE,                       /* messages */
X/* WINDOWDEPTH | WINDOWCLOSE */              /* don't use these gads */
X   WINDOWDRAG | WINDOWSIZING | NOCAREREFRESH,   /* add a few gadgets */
X   NULL,                                     /* no custom gadgets */
X   NULL,                                     /* default checkmark */
X   (UBYTE *)"F",                             /* title */
X   NULL,                                     /* initialize this! */
X   NULL,                                     /* use screen bitmap */
X   WINW, MINH, WINW, MAXH,                   /* min and max sizes */
X   WBENCHSCREEN } ;                          /* use workbench screen */
X
Xvoid initmenus()
X{
X   (void) InitProjItems();              /* Initialize the menu items */
X   (void) InitSetupItems();
X   (void) InitPrioItems();
X   (void) InitChipItems();
X   (void) InitChipAItems();
X   (void) InitSFItems();
X   (void) InitSFAItems();
X   (void) InitFastItems();
X   (void) InitFastAItems();
X   (void) InitMenu();
X   (void) StartMenus();
X   }
X
Xvoid handle_MENUPICK( class, code )
Xunsigned long class;
Xunsigned int code;
X{
X    unsigned int menunum, itemnum, subnum;
X
X    if (code == MENUNULL) return;
X
X    menunum = MENUNUM( code );
X    itemnum = ITEMNUM( code );
X    subnum  = SUBNUM( code );
X    chgflag = TRUE;
X    switch( menunum ) {
X        case 0:
X        switch( itemnum ) {
X            case 0:
X            WindowToFront(window);
X            break;
X
X            case 1:
X            WindowToBack(window);
X            break;
X
X            case 2:
X            things_are_cool = FALSE;  /* Quit */
X            break;
X            } /* end of switch ( Project itemnum ) */
X        break;
X
X        case 1:
X        switch( itemnum ) {
X            case 0:
X            switch( subnum ) {
X                case 0:
X                mode = FRAGS ;  /* Frags mode */
X                break;
X
X                case 1:
X                mmode = TRUE ;  /* Warps request */
X                break;
X                /* end of switch ( Mode subnum ) */
X                }
X            break;
X            case 1:
X            switch( subnum ) {
X                case 0:
X                delayval = 1;
X                break;
X
X                case 1:
X                delayval = 2;
X                break;
X
X                case 2:
X                delayval = 5;
X                break;
X
X                case 3:
X                delayval = 10;
X                break;
X                /* end of switch ( Freq subnum ) */
X                }
X            break;
X            /* end of switch ( Setup itemnum ) */
X            }
X        break;
X
X        case 2:
X        switch( itemnum ) {
X            case  0:
X            priority = lastpri;
X            break;
X
X            case  1:
X            priority = priority - 1;
X            break;
X
X            case  2:
X            priority = priority + 1;
X            break;
X
X            case  3:
X            priority = -99;
X            lastpri = priority;
X            break;
X
X            case  4:
X            priority = -75;
X            lastpri = priority;
X            break;
X
X            case  5:
X            priority = -50;
X            lastpri = priority;
X            break;
X
X            case  6:
X            priority = -25;
X            lastpri = priority;
X            break;
X
X            case  7:
X            priority = -20;
X            lastpri = priority;
X            break;
X
X            case  8:
X            priority = -15;
X            lastpri = priority;
X            break;
X
X            case  9:
X            priority = -10;
X            lastpri = priority;
X            break;
X
X            case 10:
X            priority =  -5;
X            lastpri = priority;
X            break;
X
X            case 11:
X            priority =   0;
X            lastpri = priority;
X            break;
X
X            case 12:
X            priority =   5;
X            lastpri = priority;
X            break;
X
X            case 13:
X            priority =  10;
X            lastpri = priority;
X            break;
X
X            case 14:
X            priority =  15;
X            lastpri = priority;
X            break;
X
X            case 15:
X            priority =  20;
X            lastpri = priority;
X            break;
X            }
X            /* end of switch ( Priority itemnum ) */
X        break;
X
X        case 3:
X        switch( itemnum ) {
X            case 0:
X            cmemsize = 0x000000;
X            break;
X
X            case 1:
X            cmemsize = 0x040000;
X            break;
X
X            case 2:
X            cmemsize = 0x080000;
X            break;
X
X            case 3:
X            cmemsize = 0x100000;
X            break;
X
X            case 4:
X            cmemsize = 0x200000;
X            break;
X            }
X            /* end of switch ( Chip Size itemnum ) */
X        break;
X
X        case 4:
X        switch( itemnum ) {
X            case 0:
X            cmembase = 0x000000;
X            break;
X
X            case 1:
X            cmembase = 0x040000;
X            break;
X
X            case 2:
X            cmembase = 0x080000;
X            break;
X
X            case 3:
X            cmembase = 0x100000;
X            break;
X            }
X            /* end of switch ( Chip Addr itemnum ) */
X        break;
X
X        case 5:
X        if (mode == WARPS)  mmode = TRUE ;
X        switch( itemnum ) {
X            case 0:
X            sfmemsize = 0x000000;
X            break;
X
X            case 1:
X            sfmemsize = 0x040000;
X            break;
X
X            case 2:
X            sfmemsize = 0x080000;
X            break;
X
X            case 3:
X            sfmemsize = 0x0C0000;
X            break;
X
X            case 4:
X            sfmemsize = 0x100000;
X            break;
X
X            case 5:
X            sfmemsize = 0x180000;
X            break;
X
X            case 6:
X            sfmemsize = 0x200000;
X            break;
X
X            case 7:
X            sfmemsize = 0x300000;
X            break;
X
X            case 8:
X            sfmemsize = 0x400000;
X            break;
X
X            case 9:
X            sfmemsize = 0x600000;
X            break;
X
X            case 10:
X            sfmemsize = 0x800000;
X            break;
X            }
X            /* end of switch ( SF Size itemnum ) */
X        break;
X
X        case 6:
X        if (mode == WARPS)  mmode = TRUE ;
X        switch( itemnum ) {
X            case 0:
X            sfmembase = 0x200000;
X            break;
X
X            case 1:
X            sfmembase = 0x240000;
X            break;
X
X            case 2:
X            sfmembase = 0x280000;
X            break;
X
X            case 3:
X            sfmembase = 0x2C0000;
X            break;
X
X            case 4:
X            sfmembase = 0x300000;
X            break;
X
X            case 5:
X            sfmembase = 0x400000;
X            break;
X
X            case 6:
X            sfmembase = 0x500000;
X            break;
X
X            case 7:
X            sfmembase = 0x600000;
X            break;
X
X            case 8:
X            sfmembase = 0x700000;
X            break;
X
X            case 9:
X            sfmembase = 0x800000;
X            break;
X
X            case 10:
X            sfmembase = 0x900000;
X            break;
X
X            case 11:
X            sfmembase = 0xC00000;
X            break;
X
X            case 12:
X            sfmembase = 0xC40000;
X            break;
X
X            case 13:
X            sfmembase = 0xC80000;
X            break;
X
X            case 14:
X            sfmembase = 0xCC0000;
X            break;
X
X            case 15:
X            sfmembase = 0xD00000;
X            break;
X            }
X            /* end of switch ( SF Addr itemnum ) */
X        break;
X
X        case 7:
X        if (mode == WARPS)  mmode = TRUE ;
X        switch( itemnum ) {
X            case 0:
X            fmemsize = 0x000000;
X            break;
X
X            case 1:
X            fmemsize = 0x040000;
X            break;
X
X            case 2:
X            fmemsize = 0x080000;
X            break;
X
X            case 3:
X            fmemsize = 0x0C0000;
X            break;
X
X            case 4:
X            fmemsize = 0x100000;
X            break;
X
X            case 5:
X            fmemsize = 0x200000;
X            break;
X
X            case 6:
X            fmemsize = 0x300000;
X            break;
X
X            case 7:
X            fmemsize = 0x400000;
X            break;
X
X            case 8:
X            fmemsize = 0x600000;
X            break;
X
X            case 9:
X            fmemsize = 0x800000;
X            break;
X
X            case 10:
X            fmemsize = 0xa000000;
X            break;
X
X            case 11:
X            fmemsize = 0xc00000;
X            break;
X
X            case 12:
X            fmemsize = 0xd00000;
X            break;
X
X            case 13:
X            fmemsize = 0xe00000;
X            break;
X
X            case 14:
X            fmemsize = 0xf00000;
X            break;
X
X            case 15:
X            fmemsize = 0x1000000;
X            break;
X            }
X            /* end of switch ( Fast Size itemnum ) */
X        break;
X
X        case 8:
X        if (mode == WARPS)  mmode = TRUE ;
X        switch( itemnum ) {
X            case 0:
X            fmembase = 0x200000;
X            break;
X
X            case 1:
X            fmembase = 0x300000;
X            break;
X
X            case 2:
X            fmembase = 0x400000;
X            break;
X
X            case 3:
X            fmembase = 0x500000;
X            break;
X
X            case 4:
X            fmembase = 0x600000;
X            break;
X
X            case 5:
X            fmembase = 0x800000;
X            break;
X
X            case 6:
X            fmembase = 0x7f0000;
X            break;
X
X            case 7:
X            fmembase = 0x7e0000;
X            break;
X
X            case 8:
X            fmembase = 0x7d00000;
X            break;
X
X            case 9:
X            fmembase = 0x7c00000;
X            break;
X
X            case 10:
X            fmembase = 0x7a00000;
X            break;
X
X            case 11:
X            fmembase = 0x7800000;
X            break;
X
X            case 12:
X            fmembase = 0x7600000;
X            break;
X
X            case 13:
X            fmembase = 0x7400000;
X            break;
X
X            case 14:
X            fmembase = 0x7200000;
X            break;
X
X            case 15:
X            fmembase = 0x7000000;
X            break;
X            }
X            /* end of switch ( Fast Addr itemnum ) */
X        break;
X        }
X        /* end of switch ( menunum ) */
X}
X
Xvoid wrack_sploot() /* this subprogram cashes in the chips in bad times */
X    {
X    if (log != 0) {
X        if (log & SA) {
X            (void) FreeMem(oldcsum, (long)(sizeof(ULONG) * warps)) ;
X            log = log & CA ;
X            }
X        if (log & S8) {
X            (void) FreeMem(csum, (long)(sizeof(ULONG) * warps)) ;
X            log = log & C8 ;
X            }
X        if (log & S4)  {
X            (void) FreeMem(sizev, (long)(sizeof(long) * frags)) ;
X            log = log & C4 ;
X            }
X        if (log & S2)  {
X            (void) FreeMem(chunkv, (long)(sizeof(long) * frags)) ;
X            log = log & C2 ;
X            }
X        if (log & S1) {
X            (void) FreeMem(cell, (long)(sizeof(USHORT) * warps)) ;
X            log = log & C1 ;
X            }
X        frags = 0;
X        warps = 0;
X        }
X}
X
XSetTimer(sec, micro, timermsg)
XULONG sec, micro;
Xstruct IOStdReq *timermsg;
X/* This routine simply sets the timer to interrupt us after secs.micros */
X{
X    timermsg->io_Command = TR_ADDREQUEST;    /* add a new timer request */
X    timermsg->io_Actual = sec;    /* seconds */
X    timermsg->io_Length = micro;    /* microseconds */
X    SendIO(timermsg);   /* post a request to the timer */
X}
X
Xvoid cleanup() {
X    if (timerport) {
X        Wait(timerbit);
X        GetMsg(timerport);
X        CloseDevice(timermsg);
X        DeleteStdIO(timermsg);
X        DeletePort(timerport);
X        }
X    if (GfxBase)        CloseLibrary(GfxBase) ;
X    if (window)         CloseWindow(window) ;
X    if (IntuitionBase)  CloseLibrary(IntuitionBase) ;
X    wrack_sploot() ;
X    exit(AARRRGH) ;
X}
X
Xvoid inittimer() {
X    if(!(timerport = (struct MsgPort *)CreatePort(0L, 0L)))cleanup();
X    if(!(timermsg = (struct IOStdReq *)CreateStdIO(timerport)))cleanup();
X    if (OpenDevice(TIMERNAME, UNIT_VBLANK, timermsg, 0L))cleanup();
X
X    timerbit = 1L << timerport->mp_SigBit ;
X    SetTimer(1L, 0L, timermsg); /* set for first message */
X}
X
Xvoid handle_NEWSIZE() /* short term allocations cashed in then realloc'd */
X    {                 /* when user hits gadget but doesn't resize window */
X    if (log & SA)  {
X        (void) FreeMem(oldcsum, (long)(sizeof(ULONG) * warps)) ;
X        log = log & CA ;
X        }
X    if (log & S8)  {
X        (void) FreeMem(csum, (long)(sizeof(ULONG) * warps)) ;
X        log = log & C8 ;
X        }
X    if (log & S1)  {
X        (void) FreeMem(cell, (long)(sizeof(USHORT) * warps)) ;
X        log = log & C1 ;
X    barh = window->Height - SIZEGAD - DRAGBAR ;  /* recalculate height */
X    barb = window->Height - SIZEGAD - 1 ; /* get new bar base position */
X    warps = barh + 1 ;       /* number of storage cells to be reserved */
X    if ((cell = (USHORT *)AllocMem((long)sizeof(USHORT) * warps,
X                                    MEMF_PUBLIC)) != 0L ) log = log | S1;
X    if ((csum = (ULONG *)AllocMem((long)sizeof(ULONG) * warps,
X                                    MEMF_PUBLIC)) != 0L ) log = log | S8;
X    if ((oldcsum = (ULONG *)AllocMem((long)sizeof(ULONG) * warps,
X                                    MEMF_PUBLIC)) != 0L ) log = log | SA;
X    if (log != SOK)  {      /* bail out if we didn't get an allocation */
X        wrack_sploot() ;
X        things_are_cool = FALSE ;     /* tell _main that we're leaving */
X        }
X    e_text.TopEdge = barb + BORDER ;        /* set the E text position */
X    intsig = FALSE ;
X    }
X}
X
Xvoid handle_MESSAGES()  {
X    unsigned long class;
X    unsigned int code, qual;
X
X    /* Wait (1L << window->UserPort->mp_SigBit); this is rediculous! */
X    while ((message=(struct IntuiMessage *)GetMsg(window->UserPort))
X                                                                != 0L) {
X        class = message->Class ;
X        code = message->Code ;
X        qual = message->Qualifier ;
X        ReplyMsg ;
X        ticker = 0 ;        /* cut short the timer to expedite service */
X        switch( class ) {
X            case MENUPICK:
X            handle_MENUPICK( class, code ) ;    /* do menus ASAP */
X            break ;
X
X            case NEWSIZE:
X            intsig = TRUE ;                     /* resize when done here */
X            break ;
X            }
X        }
X}
X
Xvoid memmometer()                /* this subprogram draws the bar graphs */
X    {
X    long i;
X    long y;
X
X    (void) handle_MESSAGES() ;  /* go see if the user wants anything */
X    i = 0 ;
X    while ((i < barh) && (intsig == FALSE)) {
X        y = barb - i ;
X        SetAPen(window->RPort, (long)cell[i]);
X        Move(window->RPort, xl, y);
X        Draw(window->RPort, xr, y);
X        i++ ;
X        }
X}
X
Xvoid shake()    /* this subprogram slings down the mercury column */
X    {
X    int i;
X
X    for (i = 0; i < barh; i++)  {
X        cell[i] = YELP ;
X        }
X}
X
Xvoid lockout()  /* this subprogram renders a whole column in border colors */
X    {
X    (void) handle_MESSAGES() ;        /* go see if the user wants anything */
X    if (intsig == FALSE)  {
X        SetAPen(window->RPort, WHTP) ;          /* set in the border color */
X        RectFill(window->RPort, xl, (barb - barh + 1), xr, barb) ; /* fill */
X        }
X}
X
Xvoid updatewarps( wf, membase, memseg )  /* this subprogram finds changes */
Xshort wf;
Xlong membase, memseg ;
X    {
X    register long i ;
X    register ULONG r ;
X    register ULONG delta ;
X    register ULONG *a ;
X
X    if (memseg == 0) {
X        (void) lockout() ;
X        return ;
X        }
X    else (void) shake() ;
X
X    delta = (ULONG)(memseg & EVENMASK) ;  /* try to avoid odd address trap */
X    r = (ULONG)(membase & EVENMASK) ;     /* prefer wrong address to death */
X    for (i = 0; i < barh; i++)  {
X        csum[i] = 0 ;
X        }
X    for (i = 0; i < barh; i++)  {
X        for (a = (ULONG *)r; a < (ULONG *)(r + delta); a++)  {
X            csum[i] ^= *a ;
X            }
X        if (oldcsum[i] != 0)  cell[i] ^= GRNP ;       /* enters with pens  */
X        if (csum[i] == oldcsum[i])  cell[i] &= GRNP ; /* all on, condition */
X        if (csum[i] == 0)  cell[i] ^= CYNP ;          /* detected clears a */
X        if (oldcsum[i] == 0xffffffff) cell[i] = CYNP ;/* pen; at the end a */
X        if (csum[i] == 0xffffffff)  cell[i] = GRNP ;  /* logical true sets */
X        oldcsum[i] = csum[i] ;                        /* a pen not yet set */
X        r += delta ;
X        }
X    (void) memmometer();
X}
X
Xvoid updatescreen( wf, membase, memseg )
Xshort wf;
Xlong membase, memseg;
X    {
X    register long size ;
X    register struct MemHeader *hdr ;
X    register struct MemChunk *chunk ;
X    extern struct ExecBase *SysBase ;
X    register long *which ;                /* active memlist chunk pointer */
X    register long newlimit ;  /* number of chunks, incl 1 null chunk, + 1 */
X    register long newfrags ;  /* number of chunks, incl null chunks, + 1  */
X    long newsize ;  /* size of next request for chunkv/sizev memory, + 1  */
X    int i, j, k, l ;
X    int length ;       /* length is number of chunks to be processed, + 1 */
X    BOOL cf, nf ;      /* cf is "chip flag" nf is "null chunk found" flag */
X
X    if (memseg == 0) {
X        (void) lockout() ;
X        return;
X        }
X    else (void) shake() ;
X
X    for (i = 0; i < 3; i++) {
X        chip[i] = 0;
X        fast[i] = 0;
X        }
X    for (i = 0; i < frags; i++) {
X        chunkv[i] = 0;
X        sizev[i] = 0;
X        }
X    newfrags = 0 ;
X    newlimit = 0 ;
X    nf = FALSE;
X    Forbid() ;
X    hdr = (struct MemHeader *) SysBase->MemList.lh_Head ;
X    while (hdr->mh_Node.ln_Succ) {
X        if (hdr->mh_Attributes & MEMF_CHIP) {
X            which = chip ;
X            cf = TRUE;
X            }
X        else {
X            which = fast ;
X            cf = FALSE;
X            }
X        if (((cf == TRUE) && (wf == 0)) || ((cf == FALSE) && (wf > 0)))  {
X            for (chunk = hdr->mh_First; chunk; chunk = chunk->mc_Next) {
X                if (which[1] < frags)  chunkv[which[1]++] = (unsigned long)chunk ;
X                size = chunk->mc_Bytes ;
X                if (which[2] < frags)  sizev[which[2]++] = (unsigned long)size;
X                *which += size ;
X                if (nf == FALSE)  {
X                    newlimit++ ;
X                    if (chunkv[newfrags] == NULL)  {
X                        nf = TRUE;
X                        }
X                    }
X                newfrags++ ;
X            }
X        }
X        hdr = (struct MemHeader *)hdr->mh_Node.ln_Succ ;
X        }
X    Permit() ;
X    length = frags ;
X    if (newlimit < frags)  length = newlimit ;
X    for (i = 0; i < length; i++)  {
X        chunkv[i] -= membase;   /* chunkv is now array offset from base   */
X        sizev[i] += chunkv[i];  /* and sizev is now address of array top  */
X        chunkv[i] = chunkv[i] / memseg;  /* this is the number of pixels  */
X        sizev[i] = sizev[i] / memseg;       /* and this is the top pixel  */
X        if (chunkv[i] < 0) chunkv[i] = 0 ;  /* we do some bounds checking */
X        if (sizev[i] < 0) sizev[i] = 0 ;
X        if (chunkv[i] >= barh) chunkv[i] = barh - 1 ;
X        if (sizev[i] >= barh) sizev[i] = barh - 1 ;
X        if (sizev[i] - chunkv[i] < 0)  sizev[i] = chunkv[i] ;
X        j = chunkv[i] ; /* from now on it will be less confusing if */
X        k = sizev[i] ;  /* we assign some variables for this stuff  */
X        if (sizev[i] - chunkv[i] == 0)  {
X            cell[j] &= BLUP ;
X            }
X        else  {
X            for (l = j; l < k; l++)  {
X                cell[l] &= BLKP ;
X                }
X            }
X        }
X    (void) memmometer();
X    newsize = frags ;
X    while (newsize < newlimit)  {
X        newsize += EXTENSION ;
X        }
X    if (newlimit > frags)  {
X        (void) FreeMem(chunkv, (long)(sizeof(long) * frags));
X        if ((chunkv = (unsigned long *)AllocMem((long)sizeof(long) * newsize,
X                                        MEMF_PUBLIC)) == 0L )  {
X            log = log & C2 ;
X            }
X        (void) FreeMem(sizev, (long)(sizeof(long) * frags));
X        if ((sizev = (unsigned long *)AllocMem((long)sizeof(long) * newsize,
X                                        MEMF_PUBLIC)) == 0L ) {
X            (void) FreeMem(chunkv, (long)(sizeof(long) * newsize));
X            log = log & C4 ;
X            }
X        if (log != SOK)  {
X            wrack_sploot() ;
X            things_are_cool = FALSE ;
X            }
X        else frags = newsize ;
X        }
X}
X
Xmain() {
X    static struct IntuiText bodyText0 =
X        {BLUP, WHTP, JAM2, 58, 10, NULL, NULL, NULL};
X    static struct IntuiText bodyText1 =
X        {BLUP, WHTP, JAM2, 42, 20, NULL, NULL, NULL};
X    static struct IntuiText bodyText2 =
X        {BLUP, WHTP, JAM2, 50, 30, NULL, NULL, NULL};
X    static struct IntuiText positiveText =
X        {BLUP, WHTP, JAM2, 7, 3, NULL, NULL, NULL};
X    static struct IntuiText negativeText =
X        {BLUP, WHTP, JAM2, 7, 3, NULL, NULL, NULL};
X    struct IntuiMessage *message;
X    ULONG class;
X    USHORT code;
X    ULONG wakeupbits;
X    long syspri;
X    char *nptr;
X    struct Task *mmtcb;
X    char oldpri;
X    int t;
X    int i;
X    USHORT colflags;     /* keeps track of column positions and counts */
X    USHORT left;         /* left   column, left edge */
X    USHORT middle;       /* middle column, left edge */
X    USHORT right;        /* right  column, left edge */
X    USHORT barw;         /* width of each mercury column */
X    USHORT wf;           /* memmometer window current column number */
X    long cmemseg;
X    long sfmemseg;
X    long fmemseg;
X    long membase;
X    long memseg;
X    long memsize;
X
X    bodyText0.IText = (UBYTE *) "WARNING! CRASH POSSIBLE";
X    bodyText1.IText = (UBYTE *) "MENU MEMORY SELECTIONS MUST";
X    bodyText2.IText = (UBYTE *) "REFERENCE EXISTING MEMORY";
X    bodyText0.NextText = &bodyText1;
X    bodyText1.NextText = &bodyText2;
X    positiveText.IText = (UBYTE *) "Risk It";
X    negativeText.IText = (UBYTE *) "Retreat";
X
X    log = 0 ;
X    if ((cell = (USHORT *)AllocMem((long)sizeof(USHORT) * BARS,
X                                        MEMF_PUBLIC)) != 0L ) log = log | S1;
X    if ((chunkv = (ULONG *)AllocMem((long)sizeof(ULONG) * STARTVAL,
X                                        MEMF_PUBLIC)) != 0L ) log = log | S2;
X    if ((sizev = (ULONG *)AllocMem((long)sizeof(ULONG) * STARTVAL,
X                                        MEMF_PUBLIC)) != 0L ) log = log | S4;
X    if ((csum = (ULONG *)AllocMem((long)sizeof(ULONG) * BARS,
X                                        MEMF_PUBLIC)) != 0L ) log = log | S8;
X    if ((oldcsum = (ULONG *)AllocMem((long)sizeof(ULONG) * BARS,
X                                        MEMF_PUBLIC)) != 0L ) log = log | SA;
X    if (log != SOK)  {
X        wrack_sploot() ;
X        exit(AARRRGH) ;
X        }
X    if ((IntuitionBase = (struct IntuitionBase *)OpenLibrary(
X            "intuition.library",33L)) != NULL &&
X            (window=OpenWindow(&newwindow)) != NULL)  {
X        if ((GfxBase = (struct GfxBase *)OpenLibrary(
X                "graphics.library", 0L)) != NULL)  {
X            (void) initmenus();
X            /* rp = window->RPort ; */
X            inittimer();
X            wf = 0;
X            mmode = FALSE ;
X            mode = FRAGS ;
X            delayval = p_rate ;
X            priority = p_priority ;
X            if (priority > 0)  priority = 0 ;
X            lastpri = priority ;
X            syspri = priority ;
X            nptr = NULL ;
X            mmtcb = FindTask( nptr ) ;
X            oldpri = SetTaskPri( mmtcb, syspri ) ;
X            cmemsize = p_chip << 10 ;
X            cmembase = p_chipa << 10 ;
X            sfmemsize = p_sf << 10 ;
X            sfmembase = p_sfa << 10 ;
X            if (p_fast >= 256)  fmemsize = p_fast << 10 ;
X            else fmemsize = p_fast << 20 ;
X            if (p_fasta <= 0)  fmembase = 0x8000000 - ((-1 * p_fasta) << 20) ;
X            else fmembase = p_fasta << 20 ;
X            while (things_are_cool == TRUE) {
X                if (chgflag != 0)  {
X                    chgflag = 0 ;
X                    colflags = 0 ;
X                    if (cmemsize != 0)  colflags = colflags | (1 << 0) ;
X                    if (sfmemsize != 0)  colflags = colflags | (1 << 1) ;
X                    if (fmemsize != 0)  colflags = colflags | (1 << 2) ;
X                    switch ( colflags ) {
X                        case 0:
X                        barw = (WINW - (2 * BORDER)) - 1 ;
X                        left = LEFT ;
X                        middle = 0 ;
X                        right = 0 ;
X                        f_text.FrontPen = ORNP ;
X                        break ;
X
X                        case 1:
X                        barw = (WINW - (2 * BORDER)) - 1 ;
X                        left = LEFT ;
X                        middle = 0 ;
X                        right = 0 ;
X                        f_text.FrontPen = BLUP ;
X                        break ;
X
X                        case 2:
X                        barw = (WINW - (2 * BORDER)) - 1 ;
X                        left = 0 ;
X                        middle = LEFT ;
X                        right = 0 ;
X                        f_text.FrontPen = CYNP ;
X                        break ;
X
X                        case 3:
X                        barw = ((WINW - (2 * BORDER)) / 2 ) - 1 ;
X                        left = LEFT ;
X                        middle = (left + barw + 1) ;
X                        right = 0 ;
X                        f_text.FrontPen = BLUP ;
X                        break ;
X
X                        case 4:
X                        barw = (WINW - (2 * BORDER)) - 1 ;
X                        left = 0 ;
X                        middle = 0;
X                        right = LEFT ;
X                        f_text.FrontPen = YELP ;
X                        break ;
X
X                        case 5:
X                        barw = ((WINW - (2 * BORDER)) / 2 ) - 1 ;
X                        left = LEFT ;
X                        middle = 0 ;
X                        right = (left + barw + 1) ;
X                        f_text.FrontPen = CYNP ;
X                        break ;
X
X                        case 6:
X                        barw = ((WINW - (2 * BORDER)) / 2 ) - 1 ;
X                        left = 0 ;
X                        middle = LEFT ;
X                        right = (middle + barw + 1) ;
X                        f_text.FrontPen = YELP ;
X                        break ;
X
X                        case 7:
X                        barw = ((WINW - (2 * BORDER)) / 3 ) - 1 ;
X                        left = LEFT ;
X                        middle = (left + barw + 1) ;
X                        right = (middle + barw + 1) ;
X                        f_text.FrontPen = BLUP ;
X                        break ;
X                        }  /* end of switch ( colflags ) */
X                    }  /* end of if ( chgflag ) */
X                cmemseg = cmemsize / barh ;
X                sfmemseg = sfmemsize / barh ;
X                fmemseg = fmemsize / barh ;
X                if (mmode == TRUE && ((sfmemsize != 0) ||
X                                      (fmemsize != 0)))  {
X                    /* Keep your eyes open here.  If we get a negative    */
X                    /* response from the requester, that means either the */
X                    /* user retreated, or a no-requester function such as */
X                    /* noreq or KillReq has selected the negative option. */
X                    /* If such functions select the positive option they  */
X                    /* force acceptance of the crash risk for Warps mode. */
X
X                    mode = AutoRequest(window, &bodyText0, &positiveText,
X                               &negativeText, 0L, 0L, 319L, 79L) ;
X                    if (mode == FALSE)  {      /* user Retreat selection  */
X                        sfmemseg = 0 ;         /* results in execution of */
X                        sfmemsize = 0 ;        /* this code segment which */
X                        fmemseg = 0 ;          /* resets to safer values  */
X                        fmemsize = 0 ;         /* resets to safer values  */
X                        }
X                    }
X                switch ( wf ) {
X                    case 0:
X                    xl = left ;
X                    membase = cmembase ;
X                    memseg = cmemseg ;
X                    memsize = cmemsize ;
X                    break;
X
X                    case 1:
X                    xl = middle ;
X                    membase = sfmembase ;
X                    memseg = sfmemseg ;
X                    memsize = sfmemsize ;
X                    break;
X
X                    case 2:
X                    xl = right ;
X                    membase = fmembase ;
X                    memseg = fmemseg ;
X                    memsize = fmemsize ;
X                    break;
X                    }  /* end of switch ( wf ) */
X                xr = xl + barw ;
X                if (mmode == TRUE)  {
X                    mode = WARPS ;
X                    mmode = FALSE ;
X                    }
X                if (xl != 0)  {
X                    if (intsig == TRUE)  {
X                        handle_NEWSIZE() ;
X                        }
X                    if (mode == WARPS)  {
X                        (void) updatewarps( wf, membase, memseg ) ;
X                        e_text.FrontPen = YELP ;
X                        }
X                    if (mode == FRAGS)  {
X                        (void) updatescreen( wf, membase, memseg ) ;
X                        e_text.FrontPen = BLUP ;
X                        }
X                    }
X                if (syspri != priority)  {
X                    syspri = priority ;
X                    nptr = NULL;
X                    mmtcb = FindTask( nptr ) ;
X                    oldpri = SetTaskPri( mmtcb, syspri ) ;
X                    }
X                if (wf == 2)  {
X                    PrintIText(window->RPort,&f_text,RTEXT,0L) ;
X                    while ( ticker > 0 )  {
X                        wakeupbits = Wait(timerbit) ;
X                        if (wakeupbits & timerbit)  {
X                            GetMsg(timerport);
X                            SetTimer(0L, TMARK, timermsg);
X                            }
X                        /* quick like, go see if the user wants anything */
X                        (void) handle_MESSAGES() ;
X                        ticker-- ;
X                        }
X                    ticker = delayval * TICKIES ;
X                    }
X                wf++ ;
X                if (wf >= 3)  wf = 0 ;
X                if (intsig == TRUE)  {
X                    handle_NEWSIZE() ;
X                    }
X                } /* end of while ( things_are_cool) */
X
X            if (timerport) {
X                Wait(timerbit);
X                GetMsg(timerport);
X                CloseDevice(timermsg);
X                DeleteStdIO(timermsg);
X                DeletePort(timerport);
X                }
X
X            if (GfxBase)    CloseLibrary(GfxBase) ;
X            }
X        if (window)         CloseWindow(window) ;
X        if (IntuitionBase)  CloseLibrary(IntuitionBase) ;
X        }
X    wrack_sploot() ;
X}
X
X_cli_parse() {}
X_wb_parse() {}
END_OF_FILE
if test 38693 -ne `wc -c <'mm.c'`; then
    echo shar: \"'mm.c'\" unpacked with wrong size!
fi
# end of 'mm.c'
fi
if test -f 'mminit.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'mminit.c'\"
else
echo shar: Extracting \"'mminit.c'\" \(27558 characters\)
sed "s/^X//" >'mminit.c' <<'END_OF_FILE'
X/* : ai=0 bk=0 ts=8 */
X#include "mm.h"
X
X#define PROJMAX 3               /* number of project menu items */
X#define SETUPMAX 2              /* number of setup menu items */
X#define MODEMAX 2
X#define FREQMAX 4               /* number of frequency menu items */
X#define PRIOMAX 16              /* number of priority menu items */
X#define CHIPMAX 5               /* number of chip mem size menu items */
X#define CHIPAMAX 6              /* number of chip mem base addr menu items */
X#define SFMAX 11                /* number of sf mem size menu items */
X#define SFAMAX 16               /* number of sf mem base addr menu items */
X#define FASTMAX 16              /* number of fast mem size menu items */
X#define FASTAMAX 16             /* number of fast mem base addr menu items */
X#define MAXMENU 9               /* total number of top level menus */
X
Xextern BOOL p_mode;             /* preset frags mode = 0, warps mode = 1 */
Xextern long p_rate;             /* preset sample interval, secs see menu */
Xextern long p_priority;         /* preset priority, range -100 to +100   */
Xextern long p_chip;             /* preset chip mem size, kbytes see menu */
Xextern long p_chipa;            /* preset chip mem address, kb  see menu */
Xextern long p_sf;               /* preset slowfast mem size, kb see menu */
Xextern long p_sfa;              /* preset slowfast mem addr, kb see menu */
Xextern long p_fast;             /* preset fast mem size, mbytes see menu */
Xextern long p_fasta;            /* preset fast mem addr, mbytes see menu */
X
X/******************************************************/
X/*    Structure declarations for the menu sections    */
X/******************************************************/
X
Xstruct   MenuItem ProjItem[PROJMAX];
Xstruct   IntuiText ProjText[PROJMAX];
Xstruct   MenuItem SetupItem[SETUPMAX];
Xstruct   IntuiText SetupText[SETUPMAX];
Xstruct   MenuItem ModeItem[MODEMAX];
Xstruct   IntuiText ModeText[MODEMAX];
Xstruct   MenuItem FreqItem[FREQMAX];
Xstruct   IntuiText FreqText[FREQMAX];
Xstruct   MenuItem PrioItem[PRIOMAX];
Xstruct   IntuiText PrioText[PRIOMAX];
Xstruct   MenuItem ChipItem[CHIPMAX];
Xstruct   IntuiText ChipText[CHIPMAX];
Xstruct   MenuItem ChipAItem[CHIPAMAX];
Xstruct   IntuiText ChipAText[CHIPAMAX];
Xstruct   MenuItem SFItem[SFMAX];
Xstruct   IntuiText SFText[SFMAX];
Xstruct   MenuItem SFAItem[SFAMAX];
Xstruct   IntuiText SFAText[SFAMAX];
Xstruct   MenuItem FastItem[FASTMAX];
Xstruct   IntuiText FastText[FASTMAX];
Xstruct   MenuItem FastAItem[FASTAMAX];
Xstruct   IntuiText FastAText[FASTAMAX];
Xstruct   Menu menu[MAXMENU];
X
X/*****************************************************************/
X/*    The following function initializes the structure arrays    */
X/*    needed to provide the Project menu topic.                  */
X/*    this was left retro-compatible with Manx 3.4a (nplus1)     */
X/*****************************************************************/
Xvoid InitProjItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<PROJMAX; n++ )
X    {
X    nplus1 = n + 1;
X    ProjItem[n].NextItem = &ProjItem[nplus1];
X    ProjItem[n].LeftEdge = 0;
X    ProjItem[n].TopEdge = 9 * n;
X    ProjItem[n].Width = 64;
X    ProjItem[n].Height = 9;
X    ProjItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP;
X    ProjItem[n].MutualExclude = 0;
X    ProjItem[n].ItemFill = (APTR)&ProjText[n];
X    ProjItem[n].SelectFill = NULL;
X    ProjItem[n].Command = 0;
X    ProjItem[n].SubItem = NULL;
X    ProjItem[n].NextSelect = 0;
X
X    ProjText[n].FrontPen = BLUP;
X    ProjText[n].BackPen = WHTP;
X    ProjText[n].DrawMode = JAM2;/* render in fore and background */
X    ProjText[n].LeftEdge = 0;
X    ProjText[n].TopEdge = 1;
X    ProjText[n].ITextFont = NULL;
X    ProjText[n].NextText = NULL;
X    }
XProjItem[PROJMAX-1].NextItem = NULL;
X
X/* initialize text for specific menu items */
X
XProjText[0].IText = (UBYTE *)"Front";
XProjText[1].IText = (UBYTE *)"Back";
XProjText[2].IText = (UBYTE *)"Quit";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Setup menu topic.                     */
X/*****************************************************************/
X
Xvoid InitSetupItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<SETUPMAX; n++ )
X    {
X    nplus1 = n + 1;
X    SetupItem[n].NextItem = &SetupItem[nplus1];
X    SetupItem[n].LeftEdge = 0;
X    SetupItem[n].TopEdge = 9 * n;
X    SetupItem[n].Width = 44;
X    SetupItem[n].Height = 9;
X    SetupItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP ;
X    SetupItem[n].MutualExclude = 0;
X    SetupItem[n].ItemFill = (APTR)&SetupText[n];
X    SetupItem[n].SelectFill = NULL;
X    SetupItem[n].Command = 0;
X    SetupItem[n].NextSelect = 0;
X
X    SetupText[n].FrontPen = BLUP;
X    SetupText[n].BackPen = WHTP;
X    SetupText[n].DrawMode = JAM2;
X    SetupText[n].LeftEdge = 0;
X    SetupText[n].TopEdge = 1;
X    SetupText[n].ITextFont = NULL;
X    SetupText[n].NextText = NULL;
X    }
XSetupItem[SETUPMAX-1].NextItem = NULL;
X
XSetupText[0].IText = (UBYTE *)"Mode";
XSetupItem[0].SubItem = ModeItem;
XSetupText[1].IText = (UBYTE *)"Freq";
XSetupItem[1].SubItem = FreqItem;
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Mode submenu topic.                   */
X/*****************************************************************/
X
Xfor( n=0; n<MODEMAX; n++ )
X    {
X    nplus1 = n + 1;
X    ModeItem[n].NextItem = &ModeItem[nplus1];
X    ModeItem[n].LeftEdge = 38;
X    ModeItem[n].TopEdge = 9 * n;
X    ModeItem[n].Width = 72;
X    ModeItem[n].Height = 9;
X    ModeItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    ModeItem[n].MutualExclude = (~(1 << n));
X    ModeItem[n].ItemFill = (APTR)&ModeText[n];
X    ModeItem[n].SelectFill = NULL;
X    ModeItem[n].Command = 0;
X    ModeItem[n].SubItem = NULL;
X    ModeItem[n].NextSelect = 0;
X
X    ModeText[n].FrontPen = BLUP;
X    ModeText[n].BackPen = WHTP;
X    ModeText[n].DrawMode = JAM2;     /* render in fore and background */
X    ModeText[n].LeftEdge = 0;
X    ModeText[n].TopEdge = 1;
X    ModeText[n].ITextFont = NULL;
X    ModeText[n].NextText = NULL;
X    }
XModeItem[MODEMAX-1].NextItem = NULL;
X
X/* select mode subitem checked */
Xswitch (p_mode) {
X    case 0:     n = 0; break;
X    case 1:     n = 1; break;
X    default:    n = 1; p_mode = FALSE;
X    }
XModeItem[n].Flags |= CHECKED;
X
X/* initialize text for specific submenu items */
XModeText[0].IText = (UBYTE *)"   Frags";
XModeText[1].IText = (UBYTE *)"   Warps";
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Freq submenu topic.                   */
X/*****************************************************************/
X
Xfor( n=0; n<FREQMAX; n++ )
X    {
X    nplus1 = n + 1;
X    FreqItem[n].NextItem = &FreqItem[nplus1];
X    FreqItem[n].LeftEdge = 38;
X    FreqItem[n].TopEdge = 9 * n;
X    FreqItem[n].Width = 88;
X    FreqItem[n].Height = 9;
X    FreqItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    FreqItem[n].MutualExclude = (~(1 << n));
X    FreqItem[n].ItemFill = (APTR)&FreqText[n];
X    FreqItem[n].SelectFill = NULL;
X    FreqItem[n].Command = 0;
X    FreqItem[n].SubItem = NULL;
X    FreqItem[n].NextSelect = 0;
X
X    FreqText[n].FrontPen = BLUP;
X    FreqText[n].BackPen = WHTP;
X    FreqText[n].DrawMode = JAM2;     /* render in fore and background */
X    FreqText[n].LeftEdge = 0;
X    FreqText[n].TopEdge = 1;
X    FreqText[n].ITextFont = NULL;
X    FreqText[n].NextText = NULL;
X    }
XFreqItem[FREQMAX-1].NextItem = NULL;
X
X/* select frequency item checked */
Xswitch (p_rate) {
X    case 1:     n = 0; break;
X    case 2:     n = 1; break;
X    case 5:     n = 2; break;
X    case 10:    n = 3; break;
X    default:    n = 1; p_rate = 2;
X    }
XFreqItem[n].Flags |= CHECKED;
X
X/* initialize text for specific menu items */
XFreqText[0].IText = (UBYTE *)"    1 Sec ";
XFreqText[1].IText = (UBYTE *)"    2 Secs";
XFreqText[2].IText = (UBYTE *)"    5 Secs";
XFreqText[3].IText = (UBYTE *)"   10 Secs";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Priority menu topic.                  */
X/*****************************************************************/
X
Xvoid InitPrioItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<PRIOMAX; n++ )
X    {
X    nplus1 = n + 1;
X    PrioItem[n].NextItem = &PrioItem[nplus1];
X    PrioItem[n].LeftEdge = 0;
X    PrioItem[n].TopEdge = 9 * n;
X    PrioItem[n].Width = 80;
X    PrioItem[n].Height = 9;
X    PrioItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    PrioItem[n].MutualExclude = (~(1 << n));
X    if (n < 3)  PrioItem[n].MutualExclude &= 0x0007;
X    if (n < 1)  PrioItem[n].MutualExclude |= 0x0007;
X    PrioItem[n].ItemFill = (APTR)&PrioText[n];
X    PrioItem[n].SelectFill = NULL;
X    PrioItem[n].Command = 0;
X    PrioItem[n].NextSelect = 0;
X
X    PrioText[n].FrontPen = BLUP;
X    PrioText[n].BackPen = WHTP;
X    if (n > 11)  {
X        PrioText[n].FrontPen = ORNP;
X        PrioText[n].BackPen = REDP;
X        }
X    PrioText[n].DrawMode = JAM2;
X    PrioText[n].LeftEdge = 0;
X    PrioText[n].TopEdge = 1;
X    PrioText[n].ITextFont = NULL;
X    PrioText[n].NextText = NULL;
X    }
XPrioItem[PRIOMAX-1].NextItem = NULL;
X
X/* select priority item checked */
Xswitch (p_priority) {
X    case  -99:     n =  3; break;
X    case  -75:     n =  4; break;
X    case  -50:     n =  5; break;
X    case  -25:     n =  6; break;
X    case  -20:     n =  7; break;
X    case  -15:     n =  8; break;
X    case  -10:     n =  9; break;
X    case   -5:     n = 10; break;
X    case    0:     n = 11; break;
X    case    5:     n = 12; break;
X    case   10:     n = 13; break;
X    case   15:     n = 14; break;
X    case   20:     n = 15; break;
X    default:       n = 11; p_priority = 0;
X    }
XPrioItem[n].Flags |= CHECKED;
X
XPrioText[ 0].IText = (UBYTE *)"   NORM   ";
XPrioText[ 1].IText = (UBYTE *)"   DECR   ";
XPrioText[ 2].IText = (UBYTE *)"   INCR   ";
XPrioText[ 3].IText = (UBYTE *)"   -99    ";
XPrioText[ 4].IText = (UBYTE *)"   -75    ";
XPrioText[ 5].IText = (UBYTE *)"   -50    ";
XPrioText[ 6].IText = (UBYTE *)"   -25    ";
XPrioText[ 7].IText = (UBYTE *)"   -20    ";
XPrioText[ 8].IText = (UBYTE *)"   -15    ";
XPrioText[ 9].IText = (UBYTE *)"   -10    ";
XPrioText[10].IText = (UBYTE *)"   -5     ";
XPrioText[11].IText = (UBYTE *)"    0     ";
XPrioText[12].IText = (UBYTE *)"    5     ";
XPrioText[13].IText = (UBYTE *)"    10    ";
XPrioText[14].IText = (UBYTE *)"    15    ";
XPrioText[15].IText = (UBYTE *)"    20    ";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Chip Mem Size menu topic.             */
X/*****************************************************************/
X
Xvoid InitChipItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<CHIPMAX; n++ )
X    {
X    nplus1 = n + 1;
X    ChipItem[n].NextItem = &ChipItem[nplus1];
X    ChipItem[n].LeftEdge = 0;
X    ChipItem[n].TopEdge = 9 * n;
X    ChipItem[n].Width = 80;
X    ChipItem[n].Height = 9;
X    ChipItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    ChipItem[n].MutualExclude = (~(1 << n));
X    ChipItem[n].ItemFill = (APTR)&ChipText[n];
X    ChipItem[n].SelectFill = NULL;
X    ChipItem[n].Command = 0;
X    ChipItem[n].NextSelect = 0;
X
X    ChipText[n].FrontPen = BLUP;
X    ChipText[n].BackPen = WHTP;
X    ChipText[n].DrawMode = JAM2;
X    ChipText[n].LeftEdge = 0;
X    ChipText[n].TopEdge = 1;
X    ChipText[n].ITextFont = NULL;
X    ChipText[n].NextText = NULL;
X    }
XChipItem[CHIPMAX-1].NextItem = NULL;
X
X/* select chip mem size item checked */
Xswitch (p_chip) {
X    case    0:     n = 0; break;
X    case  256:     n = 1; break;
X    case  512:     n = 2; break;
X    case 1024:     n = 3; break;
X    case 2048:     n = 4; break;
X    default:       n = 2; p_chip = 512;
X    }
XChipItem[n].Flags |= CHECKED;
X
XChipText[0].IText = (UBYTE *)"   NONE";
XChipText[1].IText = (UBYTE *)"   256K";
XChipText[2].IText = (UBYTE *)"   512K";
XChipText[3].IText = (UBYTE *)"   1 MB";
XChipText[4].IText = (UBYTE *)"   2 MB";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Chip Base Addr menu topic.            */
X/*****************************************************************/
X
Xvoid InitChipAItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<CHIPAMAX; n++ )
X    {
X    nplus1 = n + 1;
X    ChipAItem[n].NextItem = &ChipAItem[nplus1];
X    ChipAItem[n].LeftEdge = 0;
X    ChipAItem[n].TopEdge = 9 * n;
X    ChipAItem[n].Width = 80;
X    ChipAItem[n].Height = 9;
X    ChipAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    ChipAItem[n].MutualExclude = (~(1 << n));
X    ChipAItem[n].ItemFill = (APTR)&ChipAText[n];
X    ChipAItem[n].SelectFill = NULL;
X    ChipAItem[n].Command = 0;
X    ChipAItem[n].NextSelect = 0;
X
X    ChipAText[n].FrontPen = BLUP;
X    ChipAText[n].BackPen = WHTP;
X    ChipAText[n].DrawMode = JAM2;
X    ChipAText[n].LeftEdge = 0;
X    ChipAText[n].TopEdge = 1;
X    ChipAText[n].ITextFont = NULL;
X    ChipAText[n].NextText = NULL;
X    }
XChipAItem[CHIPAMAX-1].NextItem = NULL;
X
X/* select chip base address item checked */
Xswitch (p_chipa) {
X    case    0:     n = 0; break;
X    case  256:     n = 1; break;
X    case  512:     n = 2; break;
X    case  768:     n = 3; break;
X    case 1024:     n = 4; break;
X    case 1536:     n = 5; break;
X    default:       n = 0; p_chipa = 0;
X    }
XChipAItem[n].Flags |= CHECKED;
X
XChipAText[0].IText = (UBYTE *)"   @   0K";
XChipAText[1].IText = (UBYTE *)"   @ 256K";
XChipAText[2].IText = (UBYTE *)"   @ 512K";
XChipAText[3].IText = (UBYTE *)"   @ 768K";
XChipAText[4].IText = (UBYTE *)"   @ 1.0M";
XChipAText[5].IText = (UBYTE *)"   @ 1.5M";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Slow Fast Mem Size menu topic.        */
X/*****************************************************************/
X
Xvoid InitSFItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<SFMAX; n++ )
X    {
X    nplus1 = n + 1;
X    SFItem[n].NextItem = &SFItem[nplus1];
X    SFItem[n].LeftEdge = 0;
X    SFItem[n].TopEdge = 9 * n;
X    SFItem[n].Width = 80;
X    SFItem[n].Height = 9;
X    SFItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    SFItem[n].MutualExclude = (~(1 << n));
X    SFItem[n].ItemFill = (APTR)&SFText[n];
X    SFItem[n].SelectFill = NULL;
X    SFItem[n].Command = 0;
X    SFItem[n].NextSelect = 0;
X
X    SFText[n].FrontPen = BLUP;
X    SFText[n].BackPen = WHTP;
X    SFText[n].DrawMode = JAM2;
X    SFText[n].LeftEdge = 0;
X    SFText[n].TopEdge = 1;
X    SFText[n].ITextFont = NULL;
X    SFText[n].NextText = NULL;
X    }
XSFItem[SFMAX-1].NextItem = NULL;
X
X/* select slow fast mem size item checked */
Xswitch (p_sf) {
X    case    0:      n = 0;  break;
X    case  256:      n = 1;  break;
X    case  512:      n = 2;  break;
X    case  768:      n = 3;  break;
X    case 1024:      n = 4;  break;
X    case 1536:      n = 5;  break;
X    case 2048:      n = 6;  break;
X    case 3072:      n = 7;  break;
X    case 4096:      n = 8;  break;
X    case 6144:      n = 9;  break;
X    case 8192:      n = 10; break;
X    default:        n = 0;  p_sf = 0;
X    }
XSFItem[n].Flags |= CHECKED;
X
XSFText[ 0].IText = (UBYTE *)"   NONE  ";
XSFText[ 1].IText = (UBYTE *)"   .25 MB";
XSFText[ 2].IText = (UBYTE *)"   .5  MB";
XSFText[ 3].IText = (UBYTE *)"   .75 MB";
XSFText[ 4].IText = (UBYTE *)"   1.0 MB";
XSFText[ 5].IText = (UBYTE *)"   1.5 MB";
XSFText[ 6].IText = (UBYTE *)"   2.0 MB";
XSFText[ 7].IText = (UBYTE *)"   3.0 MB";
XSFText[ 8].IText = (UBYTE *)"   4.0 MB";
XSFText[ 9].IText = (UBYTE *)"   6.0 MB";
XSFText[10].IText = (UBYTE *)"   8.0 MB";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Slow Fast Mem Base Addr menu topic.   */
X/*****************************************************************/
X
Xvoid InitSFAItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<SFAMAX; n++ )
X    {
X    nplus1 = n + 1;
X    SFAItem[n].NextItem = &SFAItem[nplus1];
X    SFAItem[n].LeftEdge = 0;
X    SFAItem[n].TopEdge = 9 * n;
X    SFAItem[n].Width = 104;
X    SFAItem[n].Height = 9;
X    SFAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    SFAItem[n].MutualExclude = (~(1 << n));
X    SFAItem[n].ItemFill = (APTR)&SFAText[n];
X    SFAItem[n].SelectFill = NULL;
X    SFAItem[n].Command = 0;
X    SFAItem[n].NextSelect = 0;
X
X    SFAText[n].FrontPen = BLUP;
X    SFAText[n].BackPen = WHTP;
X    SFAText[n].DrawMode = JAM2;
X    SFAText[n].LeftEdge = 0;
X    SFAText[n].TopEdge = 1;
X    SFAText[n].ITextFont = NULL;
X    SFAText[n].NextText = NULL;
X    }
XSFAItem[SFAMAX-1].NextItem = NULL;
X
X/* select slow fast mem base address item checked */
Xswitch (p_sfa) {
X    case  2048:     n =  0; break;              /* 0x0800 kb =  2    mb */
X    case  2304:     n =  1; break;              /* 0x0900 kb =  2.25 mb */
X    case  2560:     n =  2; break;              /* 0x0A00 kb =  2.5  mb */
X    case  2816:     n =  3; break;              /* 0x0B00 kb =  2.75 mb */
X    case  3072:     n =  4; break;              /* 0x0C00 kb =  3    mb */
X    case  4096:     n =  5; break;              /* 0x1000 kb =  4    mb */
X    case  5120:     n =  6; break;              /* 0x1400 kb =  5    mb */
X    case  6144:     n =  7; break;              /* 0x1800 kb =  6    mb */
X    case  7168:     n =  8; break;              /* 0x1C00 kb =  7    mb */
X    case  8192:     n =  9; break;              /* 0x2000 kb =  8    mb */
X    case  9216:     n = 10; break;              /* 0x2400 kb =  9    mb */
X    case 12288:     n = 11; break;              /* 0x3000 kb = 12    mb */
X    case 12544:     n = 12; break;              /* 0x3100 kb = 12.25 mb */
X    case 12800:     n = 13; break;              /* 0x3200 kb = 12.5  mb */
X    case 13056:     n = 14; break;              /* 0x3300 kb = 12.75 mb */
X    case 13312:     n = 15; break;              /* 0x3400 kb = 13    mb */
X    default:        n =  0; p_sfa = 2048;
X    }
XSFAItem[n].Flags |= CHECKED;
X
XSFAText[ 0].IText = (UBYTE *)"   @ 2.0 Meg";
XSFAText[ 1].IText = (UBYTE *)"   @ 2.4 Meg";
XSFAText[ 2].IText = (UBYTE *)"   @ 2.8 Meg";
XSFAText[ 3].IText = (UBYTE *)"   @ 2.C Meg";
XSFAText[ 4].IText = (UBYTE *)"   @ 3.0 Meg";
XSFAText[ 5].IText = (UBYTE *)"   @ 4.0 Meg";
XSFAText[ 6].IText = (UBYTE *)"   @ 5.0 Meg";
XSFAText[ 7].IText = (UBYTE *)"   @ 6.0 Meg";
XSFAText[ 8].IText = (UBYTE *)"   @ 7.0 Meg";
XSFAText[ 9].IText = (UBYTE *)"   @ 8.0 Meg";
XSFAText[10].IText = (UBYTE *)"   @ 9.0 Meg";
XSFAText[11].IText = (UBYTE *)"   @ C.0 Meg";
XSFAText[12].IText = (UBYTE *)"   @ C.4 Meg";
XSFAText[13].IText = (UBYTE *)"   @ C.8 Meg";
XSFAText[14].IText = (UBYTE *)"   @ C.C Meg";
XSFAText[15].IText = (UBYTE *)"   @ D.0 Meg";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Fast Mem Size menu topic.             */
X/*****************************************************************/
X
Xvoid InitFastItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<FASTMAX; n++ )
X    {
X    nplus1 = n + 1;
X    FastItem[n].NextItem = &FastItem[nplus1];
X    FastItem[n].LeftEdge = 0;
X    FastItem[n].TopEdge = 9 * n;
X    FastItem[n].Width = 80;
X    FastItem[n].Height = 9;
X    FastItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    FastItem[n].MutualExclude = (~(1 << n));
X    FastItem[n].ItemFill = (APTR)&FastText[n];
X    FastItem[n].SelectFill = NULL;
X    FastItem[n].Command = 0;
X    FastItem[n].NextSelect = 0;
X
X    FastText[n].FrontPen = BLUP;
X    FastText[n].BackPen = WHTP;
X    FastText[n].DrawMode = JAM2;
X    FastText[n].LeftEdge = 0;
X    FastText[n].TopEdge = 1;
X    FastText[n].ITextFont = NULL;
X    FastText[n].NextText = NULL;
X    }
XFastItem[FASTMAX-1].NextItem = NULL;
X
X/* select fast mem size item checked */
Xswitch (p_fast) {
X    case   0:       n = 0;  break;
X    case 256:       n = 1;  break;
X    case 512:       n = 2;  break;
X    case 756:       n = 3;  break;
X    case   1:       n = 4;  break;
X    case   2:       n = 5;  break;
X    case   3:       n = 6;  break;
X    case   4:       n = 7;  break;
X    case   6:       n = 8;  break;
X    case   8:       n = 9;  break;
X    case  10:       n = 10;  break;
X    case  12:       n = 11;  break;
X    case  13:       n = 12; break;
X    case  14:       n = 13; break;
X    case  15:       n = 14; break;
X    case  16:       n = 15; break;
X    default:        n = 0;  p_fast = 0;
X    }
XFastItem[n].Flags |= CHECKED;
X
XFastText[ 0].IText = (UBYTE *)"   NONE";
XFastText[ 1].IText = (UBYTE *)"   256K";
XFastText[ 2].IText = (UBYTE *)"   512K";
XFastText[ 3].IText = (UBYTE *)"   756K";
XFastText[ 4].IText = (UBYTE *)"   1 MB";
XFastText[ 5].IText = (UBYTE *)"   2 MB";
XFastText[ 6].IText = (UBYTE *)"   3 MB";
XFastText[ 7].IText = (UBYTE *)"   4 MB";
XFastText[ 8].IText = (UBYTE *)"   6 MB";
XFastText[ 9].IText = (UBYTE *)"   8 MB";
XFastText[10].IText = (UBYTE *)"  10 MB";
XFastText[11].IText = (UBYTE *)"  12 MB";
XFastText[12].IText = (UBYTE *)"  13 MB";
XFastText[13].IText = (UBYTE *)"  14 MB";
XFastText[14].IText = (UBYTE *)"  15 MB";
XFastText[15].IText = (UBYTE *)"  16 MB";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Fast Mem Base Addr menu topic.        */
X/*****************************************************************/
X
Xvoid InitFastAItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<FASTAMAX; n++ )
X    {
X    nplus1 = n + 1;
X    FastAItem[n].NextItem = &FastAItem[nplus1];
X    FastAItem[n].LeftEdge = 0;
X    FastAItem[n].TopEdge = 9 * n;
X    FastAItem[n].Width = 80;
X    FastAItem[n].Height = 9;
X    FastAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    FastAItem[n].MutualExclude = (~(1 << n));
X    FastAItem[n].ItemFill = (APTR)&FastAText[n];
X    FastAItem[n].SelectFill = NULL;
X    FastAItem[n].Command = 0;
X    FastAItem[n].NextSelect = 0;
X
X    FastAText[n].FrontPen = BLUP;
X    FastAText[n].BackPen = WHTP;
X    FastAText[n].DrawMode = JAM2;
X    FastAText[n].LeftEdge = 0;
X    FastAText[n].TopEdge = 1;
X    FastAText[n].ITextFont = NULL;
X    FastAText[n].NextText = NULL;
X    }
XFastAItem[FASTAMAX-1].NextItem = NULL;
X
X/* select fast base address item checked */
Xswitch (p_fasta) {
X    case   2:       n = 0;   break;     /* Offset in megs above 0x0000000 */
X    case   3:       n = 1;   break;
X    case   4:       n = 2;   break;
X    case   5:       n = 3;   break;
X    case   6:       n = 4;   break;
X    case   8:       n = 5;   break;
X    case  -1:       n = 6;   break;
X    case  -2:       n = 7;   break;
X    case  -3:       n = 8;   break;     /* Offset in megs below 0x8000000 */
X    case  -4:       n = 9;   break;
X    case  -6:       n = 10;  break;
X    case  -8:       n = 11;  break;
X    case -10:       n = 12;  break;
X    case -12:       n = 13;  break;
X    case -14:       n = 14;  break;
X    case -16:       n = 15;  break;
X    default:        n =  6;  p_fasta = -1;
X    }
XFastAItem[n].Flags |= CHECKED;
X
XFastAText[ 0].IText = (UBYTE *)"   @ 2 M";
XFastAText[ 1].IText = (UBYTE *)"   @ 3 M";
XFastAText[ 2].IText = (UBYTE *)"   @ 4 M";
XFastAText[ 3].IText = (UBYTE *)"   @ 5 M";
XFastAText[ 4].IText = (UBYTE *)"   @ 6 M";
XFastAText[ 5].IText = (UBYTE *)"   @ 8 M";
XFastAText[ 6].IText = (UBYTE *)"   @7f M";
XFastAText[ 7].IText = (UBYTE *)"   @7e M";
XFastAText[ 8].IText = (UBYTE *)"   @7d M";
XFastAText[ 9].IText = (UBYTE *)"   @7c M";
XFastAText[10].IText = (UBYTE *)"   @7a M";
XFastAText[11].IText = (UBYTE *)"   @78 M";
XFastAText[12].IText = (UBYTE *)"   @76 M";
XFastAText[13].IText = (UBYTE *)"   @74 M";
XFastAText[14].IText = (UBYTE *)"   @72 M";
XFastAText[15].IText = (UBYTE *)"   @70 M";
X}
X
X/****************************************************************/
X/*   The following function inits the Menu structure array with */
X/*  appropriate values for our simple menu.  Review the manual  */
X/*  if you need to know what each value means.                  */
X/****************************************************************/
Xvoid InitMenu()
X{
Xmenu[0].NextMenu = &menu[1];
Xmenu[0].LeftEdge = 0;
Xmenu[0].TopEdge = 0;
Xmenu[0].Width = 64;
Xmenu[0].Height = 10;
Xmenu[0].Flags = MENUENABLED;
Xmenu[0].MenuName = "Project";        /* text for menu-bar display */
Xmenu[0].FirstItem = &ProjItem[0];    /* pointer to first item in list */
X
Xmenu[1].NextMenu = &menu[2];
Xmenu[1].LeftEdge = 64;
Xmenu[1].TopEdge = 0;
Xmenu[1].Width = 48;
Xmenu[1].Height = 10;
Xmenu[1].Flags = MENUENABLED;
Xmenu[1].MenuName = "Setup";          /* text for menu-bar display */
Xmenu[1].FirstItem = &SetupItem[0];   /* pointer to first item in list */
X
Xmenu[2].NextMenu = &menu[3];
Xmenu[2].LeftEdge = 112;
Xmenu[2].TopEdge = 0;
Xmenu[2].Width = 72;
Xmenu[2].Height = 10;
Xmenu[2].Flags = MENUENABLED;
Xmenu[2].MenuName = "Priority";       /* text for menu-bar display */
Xmenu[2].FirstItem = &PrioItem[0];    /* pointer to first item in list */
X
Xmenu[3].NextMenu = &menu[4];
Xmenu[3].LeftEdge = 184;
Xmenu[3].TopEdge = 0;
Xmenu[3].Width = 80;
Xmenu[3].Height = 10;
Xmenu[3].Flags = MENUENABLED;
Xmenu[3].MenuName = "Chip Size";      /* text for menu-bar display */
Xmenu[3].FirstItem = &ChipItem[0];    /* pointer to first item in list */
X
Xmenu[4].NextMenu = &menu[5];
Xmenu[4].LeftEdge = 264;
Xmenu[4].TopEdge = 0;
Xmenu[4].Width = 80;
Xmenu[4].Height = 10;
Xmenu[4].Flags = MENUENABLED;
Xmenu[4].MenuName = "Chip Addr";      /* text for menu-bar display */
Xmenu[4].FirstItem = &ChipAItem[0];   /* pointer to first item in list */
X
Xmenu[5].NextMenu = &menu[6];
Xmenu[5].LeftEdge = 344;
Xmenu[5].TopEdge = 0;
Xmenu[5].Width = 64;
Xmenu[5].Height = 10;
Xmenu[5].Flags = MENUENABLED;
Xmenu[5].MenuName = "SF Size";        /* text for menu-bar display */
Xmenu[5].FirstItem = &SFItem[0];      /* pointer to first item in list */
X
Xmenu[6].NextMenu = &menu[7];
Xmenu[6].LeftEdge = 408;
Xmenu[6].TopEdge = 0;
Xmenu[6].Width = 64;
Xmenu[6].Height = 10;
Xmenu[6].Flags = MENUENABLED;
Xmenu[6].MenuName = "SF Addr";        /* text for menu-bar display */
Xmenu[6].FirstItem = &SFAItem[0];     /* pointer to first item in list */
X
Xmenu[7].NextMenu = &menu[8];
Xmenu[7].LeftEdge = 472;
Xmenu[7].TopEdge = 0;
Xmenu[7].Width = 80;
Xmenu[7].Height = 10;
Xmenu[7].Flags = MENUENABLED;
Xmenu[7].MenuName = "Fast Size";      /* text for menu-bar display */
Xmenu[7].FirstItem = &FastItem[0];    /* pointer to first item in list */
X
Xmenu[8].NextMenu = NULL;
Xmenu[8].LeftEdge = 552;
Xmenu[8].TopEdge = 0;
Xmenu[8].Width = 80;
Xmenu[8].Height = 10;
Xmenu[8].Flags = MENUENABLED;
Xmenu[8].MenuName = "Fast Addr";      /* text for menu-bar display */
Xmenu[8].FirstItem = &FastAItem[0];   /* pointer to first item in list */
X
X}
X
Xvoid StartMenus()
X{
XSetMenuStrip(window,&menu[0]);
X}
END_OF_FILE
if test 27558 -ne `wc -c <'mminit.c'`; then
    echo shar: \"'mminit.c'\" unpacked with wrong size!
fi
# end of 'mminit.c'
fi
echo shar: End of archive 2 \(of 2\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked both archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0
--
Mail submissions (sources or binaries) to <[e-mail]>.
Mail comments to the moderator at <[e-mail]>.
Post requests for sources, and general discussion to comp.sys.amiga.misc.